/* 
 * File:   Sesion.h
 * Author: max
 *
 * Created on October 18, 2012, 7:00 PM
 */

#ifndef SESION_H
#define	SESION_H

#include <vector>
#include <time.h>
#include "common_Thread.h"
#include "common_Mutex.h"
#include "server_IManejadorSesionEvento.h"
#include "server_IMensajeEntranteManejador.h"
#include "server_IMensajero.h"
#include "server_IEnviante.h"
#include "server_SockEndPointAsincronico.h"

using namespace std;
using namespace TP;
using namespace TP::Threading;
using namespace TP::Comunicacion::Asincronica;
using namespace TP::Comunicacion::Eventos;

namespace TP { namespace Comunicacion {
    
    /**
     * @class Sesion
     * Administra la Sesion de una conexion de cliente y maneja el proceso
     */
    class Sesion : public Thread::Thread , public IMensajero, public IEnviante {

    public:
        
        Sesion(SockEndPointAsincronico* pEndPoint);
        
        virtual ~Sesion();

        void agregarMensajeEntranteManejador (IMensajeEntranteManejador* pManejador);
        
        void agregarManejadorSesionEvento (IManejadorSesionEvento* pManejador);
        
        virtual void Iniciar() throw (Excepcion&);

        virtual void Finalizar() throw (Excepcion&);

        virtual void Responder (const string& pMensaje) throw (Excepcion&);
        
        /**
         * @brief Chequea si una sesión finalizó
         * @return true si la sesion finalizó, false si no finalizó 
         */
        bool GetFinalizada ();
        
        /**
         * @brief Setea si una sesion finalizó o no
         * @param pValor = true si la sesión se setea como finalizada
         * @return false, en caso de que no haya finalizado, true si finalizó
         */
        bool SetFinalizada (bool pValor);
        
        /**
         * @brief Chequea si una sesión fue autenticada
         * @return true si la sesión fue autenticada, false si no fue 
         * autenticada
         */
        bool GetAutenticada();
        
        /** 
         * @brief Setea si una sesión se autenticó o no
         * @param pValor = true si se setea la sesión como autenticada, false
         * en caso de que no se setee como autenticada
         * @return true si esta autenticada la sesion, false si no
         */
        bool SetAutenticada(bool pValor);
        
        /**
         * @brief Obtiene el nombre de usuario
         * @return Nombre del usuario
         */
        string GetUsuario();
        
        /**
         * @brief Setea el nombre de usuario
         * @param pValor = nombre del usuario
         * @return Nombre del usuario
         */
        string SetUsuario(const string& pValor);
        
        string& GetCredencial ();
        
        /**
         * @brief Actualiza la hora del último evento ocurrido en la sesión
         * @param hora tiempo en segundos del evento registrado.
         * @return VOID
         */
        void ActualizarHora(time_t & hora);
        
        /**
         * @brief Obtiene el tiempo de ejecución del último evento registrado 
         * en la sesión
         * @return Devuelve la hora en segundos del último evento registrado
         */
        time_t GetHora();
        
    protected:

        virtual void tarea ();
        
    private:

        bool EsCredencial (const string & pMensaje);

        const string& notificarMensaje (const string& pMensaje);
        SockEndPointAsincronico* _endPoint;
        IManejadorSesionEvento* manejadorSesionEvento;
        vector<IMensajeEntranteManejador* > mensajeSesionManejadores;
        
        bool errorConexion;
        
        bool _sesionFinalizada;
        Mutex _sesionFinalizadaMutex;
        
        bool _autenticada;
        Mutex _autenticadaMutex;
        
        string _usuario;
        Mutex _usuarioMutex;
        
        string _credencial;
        
        time_t _hora_conexion;
        Mutex _hora_conexion_Mutex;
    };
}}

#endif	/* SESION_H */

